﻿namespace HutongGames.PlayMakerEditor
{
    using HutongGames.PlayMaker;
    using System;
    using System.Runtime.CompilerServices;
    using UnityEditor;
    using UnityEngine;

    [Serializable]
    internal static class FsmEditorSettings
    {
        [CompilerGenerated]
        private static bool AddPrefabLabel__BackingField;
        [CompilerGenerated]
        private static bool AutoAddPlayMakerGUI__BackingField;
        [CompilerGenerated]
        private static bool AutoLoadPrefabs__BackingField;
        [CompilerGenerated]
        private static bool AutoSelectGameObject__BackingField;
        [CompilerGenerated]
        private static bool BreakpointsEnabled__BackingField;
        [CompilerGenerated]
        private static bool CheckForCollisionEventErrors__BackingField;
        [CompilerGenerated]
        private static bool CheckForDuplicateTransitionEvent__BackingField;
        [CompilerGenerated]
        private static bool CheckForEventNotUsed__BackingField;
        [CompilerGenerated]
        private static bool CheckForMouseEventErrors__BackingField;
        [CompilerGenerated]
        private static bool CheckForObsoleteActions__BackingField;
        [CompilerGenerated]
        private static bool CheckForPrefabRestrictions__BackingField;
        [CompilerGenerated]
        private static bool CheckForRequiredComponent__BackingField;
        [CompilerGenerated]
        private static bool CheckForRequiredField__BackingField;
        [CompilerGenerated]
        private static bool CheckForTransitionMissingEvent__BackingField;
        [CompilerGenerated]
        private static bool CheckForTransitionMissingTarget__BackingField;
        [CompilerGenerated]
        private static bool CloseActionBrowserOnEnter__BackingField;
        [CompilerGenerated]
        private static bool ColorLinks__BackingField;
        [CompilerGenerated]
        private static HutongGames.PlayMakerEditor.FsmEditorStyles.ColorScheme ColorScheme__BackingField;
        [CompilerGenerated]
        private static int ConsoleActionReportSortOptionIndex__BackingField;
        [CompilerGenerated]
        private static bool DebugActionParameters__BackingField;
        [CompilerGenerated]
        private static Color DebugLookAtColor__BackingField;
        [CompilerGenerated]
        private static Color DebugRaycastColor__BackingField;
        [CompilerGenerated]
        private static bool DebugVariables__BackingField;
        [CompilerGenerated]
        private static bool DimUnusedActionParameters__BackingField;
        [CompilerGenerated]
        private static bool DisableActionBrowerWhenPlaying__BackingField;
        [CompilerGenerated]
        private static bool DisableEditorWhenPlaying__BackingField;
        [CompilerGenerated]
        private static bool DisableErrorCheckerWhenPlaying__BackingField;
        [CompilerGenerated]
        private static bool DisableEventBrowserWhenPlaying__BackingField;
        [CompilerGenerated]
        private static bool DisableInspectorWhenPlaying__BackingField;
        [CompilerGenerated]
        private static bool DisableToolWindowsWhenPlaying__BackingField;
        [CompilerGenerated]
        private static bool DrawPlaymakerGizmoInHierarchy__BackingField;
        [CompilerGenerated]
        private static bool DrawPlaymakerGizmos__BackingField;
        [CompilerGenerated]
        private static float EdgeScrollSpeed__BackingField;
        [CompilerGenerated]
        private static float EdgeScrollZone__BackingField;
        [CompilerGenerated]
        private static bool EnableDebugFlow__BackingField;
        [CompilerGenerated]
        private static bool EnableLogging__BackingField;
        [CompilerGenerated]
        private static bool EnableRealtimeErrorChecker__BackingField;
        [CompilerGenerated]
        private static bool EnableWatermarks__BackingField;
        [CompilerGenerated]
        private static bool ExpandDebuggingSettings__BackingField;
        [CompilerGenerated]
        private static bool ExpandErrorCheckSettings__BackingField;
        [CompilerGenerated]
        private static bool ExpandGeneralSettings__BackingField;
        [CompilerGenerated]
        private static bool ExpandGraphViewSettings__BackingField;
        [CompilerGenerated]
        private static bool FrameSelectedState__BackingField;
        [CompilerGenerated]
        private static bool FsmBrowserShowFullPath__BackingField;
        [CompilerGenerated]
        private static int GameStateIconSize__BackingField;
        [CompilerGenerated]
        private static HutongGames.PlayMakerEditor.GraphViewLinkStyle GraphViewLinkStyle__BackingField;
        [CompilerGenerated]
        private static bool HideObsoleteActions__BackingField;
        [CompilerGenerated]
        private static bool HideUnusedEvents__BackingField;
        [CompilerGenerated]
        private static bool HideUnusedParams__BackingField;
        [CompilerGenerated]
        private static bool JumpToBreakpoint__BackingField;
        [CompilerGenerated]
        private static bool KeepActionBrowserOpen__BackingField;
        [CompilerGenerated]
        private static bool LoadAllPrefabs__BackingField;
        [CompilerGenerated]
        private static bool LockGraphView__BackingField;
        [CompilerGenerated]
        private static bool LogCollapseSystemEvents__BackingField;
        [CompilerGenerated]
        private static bool LogHideUnusedEvents__BackingField;
        [CompilerGenerated]
        private static bool LogPauseOnSelect__BackingField;
        [CompilerGenerated]
        private static bool LogShowSentBy__BackingField;
        [CompilerGenerated]
        private static int MaxReEnterStateCount__BackingField;
        [CompilerGenerated]
        private static bool MirrorDebugLog__BackingField;
        [CompilerGenerated]
        private static string NewStateName__BackingField;
        [CompilerGenerated]
        private static string ScreenshotsPath__BackingField;
        [CompilerGenerated]
        private static int SelectedActionCategory__BackingField;
        [CompilerGenerated]
        private static bool SelectFSMInGameView__BackingField;
        [CompilerGenerated]
        private static bool SelectNewVariables__BackingField;
        [CompilerGenerated]
        private static bool SelectStateOnActivated__BackingField;
        [CompilerGenerated]
        private static bool ShowActionParameters__BackingField;
        [CompilerGenerated]
        private static bool ShowActionPreview__BackingField;
        [CompilerGenerated]
        private static bool ShowCommentsInGraphView__BackingField;
        [CompilerGenerated]
        private static bool ShowEditWhileRunningWarning__BackingField;
        [CompilerGenerated]
        private static bool ShowHints__BackingField;
        [CompilerGenerated]
        private static bool ShowScrollBars__BackingField;
        [CompilerGenerated]
        private static bool ShowStateDescription__BackingField;
        [CompilerGenerated]
        private static bool ShowStateLabelsInGameView__BackingField;
        [CompilerGenerated]
        private static int SnapGridSize__BackingField;
        [CompilerGenerated]
        private static string StartStateName__BackingField;
        [CompilerGenerated]
        private static int StateMaxWidth__BackingField;
        [CompilerGenerated]
        private static bool SyncLogSelection__BackingField;
        [CompilerGenerated]
        private static bool UnloadPrefabs__BackingField;
        public const int MaxStateNameLength = 100;
        public const string ProductCopyright = "\x00a9 Hutong Games LLC. All Rights Reserved.";
        public const string ProductName = "playMaker";
        public const string ProductUrl = "http://hutonggames.com/";
        private static Vector2 scrollPosition;

        private static void ApplySettings()
        {
            FsmLog.MirrorDebugLog = MirrorDebugLog;
            FsmLog.LoggingEnabled = EnableLogging;
            FsmLog.EnableDebugFlow = EnableDebugFlow;
            FsmDebugger.EnableBreakpoints(BreakpointsEnabled);
            FsmDebugger.SetInfiniteLoopThreshold(MaxReEnterStateCount);
            PlayMakerFSM.DrawGizmos = DrawPlaymakerGizmos;
            Fsm.DebugLookAtColor = DebugLookAtColor;
            Fsm.DebugRaycastColor = DebugRaycastColor;
            PlayMakerGUI.EnableStateLabels = ShowStateLabelsInGameView;
        }

        private static void DoDebuggingSettings()
        {
            MaxReEnterStateCount = EditorGUILayout.IntField(new GUIContent("Infinite Loop Threshold", "The maximum number of times a state is allowed to immediately re-enter itself before being considered an infinite loop that should be broken out of."), MaxReEnterStateCount, new GUILayoutOption[0]);
            ShowStateLabelsInGameView = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Show State Labels in Game View", "Turns all state labels off/on in the Game View"), ShowStateLabelsInGameView);
            JumpToBreakpoint = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Jump to Breakpoint/Error", "Should the editor automatically jump to a breakpoint/error. Note: This can often mean switching to a different Fsm."), JumpToBreakpoint);
            MirrorDebugLog = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Forward Playmaker Log to Unity Log", "The Playmaker Log is easier to filter by Fsm, but the Unity Log lets you see all log events in context."), MirrorDebugLog);
            EnableLogging = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Enable Logging", "Enable logging of events, state changes etc. Can improve performance when disabled."), EnableLogging);
            EnableDebugFlow = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Enable DebugFlow", "Enable recording of variables and other state information for DebugFlow mode. This is a global setting; if enabled, you can still enable/disable it on individual FSMs as necessary. Can improve performance when disabled."), EnableDebugFlow);
            DebugLookAtColor = EditorGUILayout.ColorField("Debug Look At Color", DebugLookAtColor, new GUILayoutOption[0]);
            DebugRaycastColor = EditorGUILayout.ColorField("Debug Raypick Color", DebugRaycastColor, new GUILayoutOption[0]);
        }

        private static void DoErrorCheckSettings()
        {
            bool changed = GUI.changed;
            EnableRealtimeErrorChecker = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Enable Real-Time Error Checker", "If larger projects start to slow down in the editor you can disable the real time error checking and use the manual Refresh button in the Error Check window instead."), EnableRealtimeErrorChecker);
            DisableErrorCheckerWhenPlaying = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Disable Error Checker When Game Is Playing", "Disable the real time error checking to improve playback performance in the editor."), DisableErrorCheckerWhenPlaying);
            CheckForRequiredComponent = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Required Components", "Enable/Disable error checking for required components. Can be useful to disable if you add components at runtime."), CheckForRequiredComponent);
            CheckForRequiredField = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Required Action Fields", "Enable/Disable error checking for required action fields. These are field that must be specified for the action to work correctly."), CheckForRequiredField);
            CheckForEventNotUsed = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Events Not Used by Target FSM", "Enable/Disable error checking for events not used by target FSM. E.g., check events sendt by actions."), CheckForEventNotUsed);
            CheckForTransitionMissingEvent = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Transitions Missing Events", "Enable/Disable error checking for transitions without events."), CheckForTransitionMissingEvent);
            CheckForTransitionMissingTarget = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Transitions Missing Targets", "Enable/Disable error checking for transitions without targets."), CheckForTransitionMissingTarget);
            CheckForDuplicateTransitionEvent = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Duplicate Transition Events", "Enable/Disable error checking for transitions with the same event."), CheckForDuplicateTransitionEvent);
            CheckForMouseEventErrors = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Setup Errors With Mouse Events", "Enable/Disable error checking for owner setup for mouse events."), CheckForMouseEventErrors);
            CheckForCollisionEventErrors = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Setup Errors With Collision Events", "Enable/Disable error checking for owner setup for collision events."), CheckForCollisionEventErrors);
            CheckForPrefabRestrictions = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Prefab Restrictions", "Enable/Disable error checking for prefabs referencing scene objects."), CheckForPrefabRestrictions);
            CheckForObsoleteActions = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Check for Obsolete Actions", "Enable/Disable error checking for actions that have been marked obsolete."), CheckForObsoleteActions);
            if (GUI.changed)
            {
                FsmErrorChecker.Refresh();
                FsmEditor.RepaintAll();
            }
            else
            {
                GUI.changed = changed;
            }
        }

        private static void DoGeneralSettings()
        {
            ShowHints = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Show Hint Boxes in the Editor", "Useful when you're learning PlayMaker. Toggle on/off with F1."), ShowHints);
            AutoAddPlayMakerGUI = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Auto Add PlayMakerGUI to Scene", "Automatically adds a PlayMakerGUI component to the scene (if necessary) when you add or select an FSM. Note, you need a PlayMakerGUI in the scene to see Playmaker Gizmos, OnGUI actions and iTween path editing."), AutoAddPlayMakerGUI);
            DisableEditorWhenPlaying = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Disable PlayMaker Editor When Game Is Playing", "If you find performance too slow with the editor running, you can turn it off here."), DisableEditorWhenPlaying);
            DisableInspectorWhenPlaying = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Disable the Inspector Panel When Game Is Playing ", "Useful if you want to see the Graph View, but the inspector panel slows the game down too much."), DisableInspectorWhenPlaying);
            DisableToolWindowsWhenPlaying = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Disable Tool Windows When Game Is Playing", "If you find performance too slow with the editor running, you can try disabling the tool windows. Note, some tool windows can be enabled/disabled individually in their Settings Menu."), DisableToolWindowsWhenPlaying);
            bool flag = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Draw Playmaker Gizmos in Scene View", "Draw the Playmaker Gizmo on game objects with FSMs in the scene view."), DrawPlaymakerGizmos);
            if (flag != DrawPlaymakerGizmos)
            {
                DrawPlaymakerGizmos = flag;
                PlayMakerFSM.DrawGizmos = flag;
                GUI.changed = true;
            }
            flag = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Draw Playmaker Gizmos in Hierarchy", "Draw the Playmaker Gizmo on game objects with FSMs in the hierarchy view."), DrawPlaymakerGizmoInHierarchy);
            if (flag != DrawPlaymakerGizmoInHierarchy)
            {
                DrawPlaymakerGizmoInHierarchy = flag;
                EditorApplication.RepaintHierarchyWindow();
            }
            EditorApplication.RepaintHierarchyWindow();
            AutoSelectGameObject = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Select GameObject When FSM Selected", "Should the GameObject that owns an FSM be automatically selected when selecting the FSM."), AutoSelectGameObject);
            SelectStateOnActivated = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Select State On Activated", "Should activated states be auto-selected. Selected states are visible in the inspector."), SelectStateOnActivated);
            SelectFSMInGameView = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Select Game Objects With FSMs in Game View", "Lets you click on game objects in a running game to select their state machines. NOTE: only works on game objects with colliders."), SelectFSMInGameView);
            ShowEditWhileRunningWarning = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Show Editing While Running Warning", "Shows a non-modal warning the first time you edit an FSM after running the game. A gentle reminder!"), ShowEditWhileRunningWarning);
            CloseActionBrowserOnEnter = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Close Action Browser After Adding Action", "Useful if you like to use the Action Browser as a popup, e.g., with the ~ key."), CloseActionBrowserOnEnter);
            DimUnusedActionParameters = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Dim Unused Action Parameters", "Dims unused optional parameters in the Action Editor. Can help reduce visual clutter."), DimUnusedActionParameters);
            LoadAllPrefabs = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Load All PlayMakerFSM Prefabs When Refactoring.", "Load all prefabs in the project when renaming events and variables."), LoadAllPrefabs);
            AutoLoadPrefabs = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Auto Load Prefabs in Scene", "Automatically load any prefabs used in a scene."), AutoLoadPrefabs);
            AddPrefabLabel = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Add Prefab Labels", "Add (Prefab) to prefab labels."), AddPrefabLabel);
        }

        private static void DoGraphViewSettings()
        {
            HutongGames.PlayMakerEditor.FsmEditorStyles.ColorScheme scheme = (HutongGames.PlayMakerEditor.FsmEditorStyles.ColorScheme) EditorGUILayout.EnumPopup(new GUIContent("Color Scheme", "Default pickes a color scheme that matched Pro/Indie skins."), ColorScheme, new GUILayoutOption[0]);
            if (scheme != ColorScheme)
            {
                ColorScheme = scheme;
                FsmEditorStyles.Init();
            }
            GraphViewLinkStyle = (HutongGames.PlayMakerEditor.GraphViewLinkStyle) EditorGUILayout.EnumPopup(new GUIContent("Graph View Link Style", "Various link styles..."), GraphViewLinkStyle, new GUILayoutOption[0]);
            NewStateName = EditorGUILayout.TextField(new GUIContent("New State Name", "The default name for new states. Note: State names must be unique within each Fsm. Auto named states will append numbers when necessary."), NewStateName, new GUILayoutOption[0]);
            int num = EditorGUILayout.IntField(new GUIContent("Max State Width", "How wide a State box can grow to accomodate its contents. Default is 200."), StateMaxWidth, new GUILayoutOption[0]);
            if (num != StateMaxWidth)
            {
                StateMaxWidth = num;
                FsmBuilder.UpdateAllStateSizes();
            }
            SnapGridSize = EditorGUILayout.IntField(new GUIContent("Snap Grid Size", "Size of the grid used to snap states when draggin with ctrl held down."), SnapGridSize, new GUILayoutOption[0]);
            EdgeScrollSpeed = EditorGUILayout.FloatField(new GUIContent("Edge Scroll Speed", "Sets how fast the view scrolls when dragging states/transitions near the edge of the Graph View. Default is 10, smaller is slower."), EdgeScrollSpeed, new GUILayoutOption[0]);
            FrameSelectedState = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Auto Frame Selected State", "Should the graph view auto frame selected states."), FrameSelectedState);
            bool flag = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Show Comments in Graph View", "Add descriptions to FSMs and States and see them in the Graph View"), ShowCommentsInGraphView);
            if (flag != ShowCommentsInGraphView)
            {
                ShowCommentsInGraphView = flag;
                FsmBuilder.UpdateAllStateSizes();
                GUI.changed = true;
            }
            ColorLinks = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Color Links With State Color", "Use the state color to color transition links from the state."), ColorLinks);
            ShowScrollBars = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Show Scrollbars All The Time", "When disabled, scrollbars are only shown when you drag the canvas. Note: Use the middle mouse button to drag the canvas."), ShowScrollBars);
            EnableWatermarks = FsmEditorGUILayout.RightAlignedToggle(new GUIContent("Enable Watermarks", "Enable the large title text and graphic watermarks drawn in the background. NOTE: Try disabling this on slower computers if you experience editor slowdown."), EnableWatermarks);
            ScreenshotsPath = EditorGUILayout.TextField(new GUIContent("FSM Screenshots Directory", "Where to save FSM screenshots. The path is relative to the Unity project directory. NOTE: It is not recommended to use a directory under Assets, since Unity will add it to the project's assets."), ScreenshotsPath, new GUILayoutOption[0]);
        }

        public static void LoadSettings()
        {
            ScreenshotsPath = EditorPrefs.GetString("PlayMaker.ScreenshotsPath", "PlayMaker/Screenshots");
            DebugVariables = EditorPrefs.GetBool("PlayMaker.DebugVariables", false);
            ConsoleActionReportSortOptionIndex = EditorPrefs.GetInt("PlayMaker.ConsoleActionReportSortOptionIndex", 1);
            LogPauseOnSelect = EditorPrefs.GetBool("PlayMaker.LogPauseOnSelect", true);
            LogCollapseSystemEvents = EditorPrefs.GetBool("PlayMaker.LogCollapseSystemEvents", true);
            LogHideUnusedEvents = EditorPrefs.GetBool("PlayMaker.LogHideUnusedEvents", true);
            LogShowSentBy = EditorPrefs.GetBool("PlayMaker.LogShowSentBy", true);
            ShowHints = EditorPrefs.GetBool("PlayMaker.ShowHints", true);
            CloseActionBrowserOnEnter = EditorPrefs.GetBool("PlayMaker.CloseActionBrowserOnEnter", false);
            DisableEditorWhenPlaying = EditorPrefs.GetBool("PlayMaker.DisableEditorWhenPlaying", false);
            DisableInspectorWhenPlaying = EditorPrefs.GetBool("PlayMaker.DisableInspectorWhenPlaying", false);
            DisableToolWindowsWhenPlaying = EditorPrefs.GetBool("PlayMaker.DisableToolWindowsWhenPlaying", true);
            DisableActionBrowerWhenPlaying = EditorPrefs.GetBool("PlayMaker.DisableActionBrowerWhenPlaying", false);
            DisableEventBrowserWhenPlaying = EditorPrefs.GetBool("PlayMaker.DisableEventBrowserWhenPlaying", false);
            ColorScheme = (HutongGames.PlayMakerEditor.FsmEditorStyles.ColorScheme) EditorPrefs.GetInt("PlayMaker.ColorScheme", 0);
            EnableRealtimeErrorChecker = EditorPrefs.GetBool("PlayMaker.EnableRealtimeErrorChecker", true);
            CheckForRequiredComponent = EditorPrefs.GetBool("PlayMaker.CheckForRequiredComponent", true);
            CheckForRequiredField = EditorPrefs.GetBool("PlayMaker.CheckForRequiredField", true);
            CheckForEventNotUsed = EditorPrefs.GetBool("PlayMaker.CheckForEventNotUsed", true);
            CheckForTransitionMissingEvent = EditorPrefs.GetBool("PlayMaker.CheckForTransitionMissingEvent", true);
            CheckForTransitionMissingTarget = EditorPrefs.GetBool("PlayMaker.CheckForTransitionMissingTarget", true);
            CheckForDuplicateTransitionEvent = EditorPrefs.GetBool("PlayMaker.CheckForDuplicateTransitionEvent", true);
            CheckForMouseEventErrors = EditorPrefs.GetBool("PlayMaker.CheckForMouseEventErrors", true);
            CheckForCollisionEventErrors = EditorPrefs.GetBool("PlayMaker.CheckForCollisionEventErrors", true);
            CheckForPrefabRestrictions = EditorPrefs.GetBool("PlayMaker.CheckForPrefabRestrictions", true);
            CheckForObsoleteActions = EditorPrefs.GetBool("PlayMaker.CheckForObsoleteActions", true);
            ExpandDebuggingSettings = EditorPrefs.GetBool("PlayMaker.ExpandDebuggingSettings", false);
            ExpandErrorCheckSettings = EditorPrefs.GetBool("PlayMaker.ExpandErrorCheckSettings", false);
            ExpandGeneralSettings = EditorPrefs.GetBool("PlayMaker.ExpandFsmSettings", false);
            ExpandGraphViewSettings = EditorPrefs.GetBool("PlayMaker.ExpandGraphViewSettings", false);
            EdgeScrollZone = EditorPrefs.GetFloat("PlayMaker.AutoPanZone", 100f);
            EdgeScrollSpeed = EditorPrefs.GetFloat("PlayMaker.AutoPanSpeed", 5f);
            HideObsoleteActions = EditorPrefs.GetBool("PlayMaker.HideObsoleteActions", true);
            ColorLinks = EditorPrefs.GetBool("PlayMaker.ColorLinks", false);
            DisableErrorCheckerWhenPlaying = EditorPrefs.GetBool("PlayMaker.DisableErrorCheckerWhenPlaying", true);
            EnableLogging = EditorPrefs.GetBool("PlayMaker.EnableLogging", true);
            SnapGridSize = EditorPrefs.GetInt("PlayMaker.SnapGridSize", 0x10);
            ShowScrollBars = EditorPrefs.GetBool("PlayMaker.ShowScrollBars", true);
            EnableWatermarks = EditorPrefs.GetBool("PlayMaker.ShowWatermark", true);
            StateMaxWidth = EditorPrefs.GetInt("PlayMaker.StateMaxWidth", 200);
            AddPrefabLabel = EditorPrefs.GetBool("PlayMaker.AddPrefabLabel", true);
            AutoLoadPrefabs = EditorPrefs.GetBool("PlayMaker.AutoLoadPrefabs", true);
            LoadAllPrefabs = EditorPrefs.GetBool("PlayMaker.LoadAllPrefabs", true);
            UnloadPrefabs = EditorPrefs.GetBool("PlayMaker.UnloadPrefabs", true);
            StartStateName = EditorPrefs.GetString("PlayMaker.StartStateName", "State 1");
            NewStateName = EditorPrefs.GetString("PlayMaker.NewStateName", "State");
            AutoSelectGameObject = EditorPrefs.GetBool("PlayMaker.AutoSelectGameObject", true);
            SelectStateOnActivated = EditorPrefs.GetBool("PlayMaker.SelectStateOnActivated", true);
            JumpToBreakpoint = EditorPrefs.GetBool("PlayMaker.GotoBreakpoint", true);
            GameStateIconSize = EditorPrefs.GetInt("PlayMaker.GameStateIconSize", 0x20);
            FrameSelectedState = EditorPrefs.GetBool("PlayMaker.FrameSelectedState", false);
            SyncLogSelection = EditorPrefs.GetBool("PlayMaker.SyncLogSelection", true);
            BreakpointsEnabled = EditorPrefs.GetBool("PlayMaker.BreakpointsEnabled", true);
            MirrorDebugLog = EditorPrefs.GetBool("PlayMaker.MirrorDebugLog", false);
            LockGraphView = EditorPrefs.GetBool("PlayMaker.LockGraphView", false);
            GraphViewLinkStyle = (HutongGames.PlayMakerEditor.GraphViewLinkStyle) EditorPrefs.GetInt("PlayMaker.GraphLinkStyle", 0);
            KeepActionBrowserOpen = true;
            ShowCommentsInGraphView = EditorPrefs.GetBool("PlayMaker.ShowCommentsInGraphView", true);
            ShowStateLabelsInGameView = EditorPrefs.GetBool("PlayMaker.ShowStateLabelsInGameView", true);
            DrawPlaymakerGizmos = EditorPrefs.GetBool("PlayMaker.DrawPlaymakerGizmos", true);
            DrawPlaymakerGizmoInHierarchy = EditorPrefs.GetBool("PlayMaker.DrawPlaymakerGizmoInHierarchy", true);
            ShowEditWhileRunningWarning = EditorPrefs.GetBool("PlayMaker.ShowEditWhileRunningWarning", true);
            MaxReEnterStateCount = EditorPrefs.GetInt("PlayMaker.MaxReenterStateCount", 100);
            ShowStateDescription = EditorPrefs.GetBool("PlayMaker.ShowStateDescription", true);
            ShowActionParameters = EditorPrefs.GetBool("PlayMaker.ShowActionParameters", true);
            DebugActionParameters = EditorPrefs.GetBool("PlayMaker.DebugActionParameters", false);
            HideUnusedEvents = EditorPrefs.GetBool("PlayMaker.HideUnusedEvents", false);
            ShowActionPreview = EditorPrefs.GetBool("PlayMaker.ShowActionPreview", true);
            SelectedActionCategory = EditorPrefs.GetInt("PlayMaker.SelectedActionCategory", 0);
            SelectFSMInGameView = EditorPrefs.GetBool("PlayMaker.SelectFSMInGameView", true);
            DebugLookAtColor = FsmEditorUtility.UnpackColorFromInt(EditorPrefs.GetInt("PlayMaker.DebugLookAtColor", FsmEditorUtility.PackColorIntoInt(Color.gray)));
            DebugRaycastColor = FsmEditorUtility.UnpackColorFromInt(EditorPrefs.GetInt("PlayMaker.DebugRaycastColor", FsmEditorUtility.PackColorIntoInt(Color.gray)));
            HideUnusedParams = EditorPrefs.GetBool("PlayMaker.HideUnusedParams", false);
            AutoAddPlayMakerGUI = EditorPrefs.GetBool("PlayMaker.AutoAddPlayMakerGUI", true);
            DimUnusedActionParameters = EditorPrefs.GetBool("PlayMaker.DimUnusedParameters", false);
            SelectNewVariables = EditorPrefs.GetBool("PlayMaker.SelectNewVariables", true);
            FsmBrowserShowFullPath = EditorPrefs.GetBool("PlayMaker.FsmBrowserShowFullPath", true);
            EnableDebugFlow = EditorPrefs.GetBool("PlayMaker.EnableDebugFlow", true);
            ValidateSettings();
            ApplySettings();
        }

        public static void OnGUI()
        {
            scrollPosition = GUILayout.BeginScrollView(scrollPosition, new GUILayoutOption[0]);
            EditorGUIUtility.LookLikeControls(180f, 120f);
            bool changed = GUI.changed;
            GUI.changed = false;
            GUILayout.Label("Preferences", EditorStyles.boldLabel, new GUILayoutOption[0]);
            ExpandGeneralSettings = FsmEditorGUILayout.BoldFoldout(ExpandGeneralSettings, new GUIContent("General"));
            if (ExpandGeneralSettings)
            {
                DoGeneralSettings();
            }
            ExpandGraphViewSettings = FsmEditorGUILayout.BoldFoldout(ExpandGraphViewSettings, new GUIContent("Graph View"));
            if (ExpandGraphViewSettings)
            {
                DoGraphViewSettings();
            }
            ExpandDebuggingSettings = FsmEditorGUILayout.BoldFoldout(ExpandDebuggingSettings, new GUIContent("Debugging"));
            if (ExpandDebuggingSettings)
            {
                DoDebuggingSettings();
            }
            ExpandErrorCheckSettings = FsmEditorGUILayout.BoldFoldout(ExpandErrorCheckSettings, new GUIContent("Error Checking"));
            if (ExpandErrorCheckSettings)
            {
                DoErrorCheckSettings();
            }
            if (GUI.changed)
            {
                ValidateSettings();
                ApplySettings();
                SaveSettings();
            }
            else
            {
                GUI.changed = changed;
            }
            GUILayout.EndScrollView();
            FsmEditorGUILayout.Divider(new GUILayoutOption[0]);
            EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
            if (GUILayout.Button("Restore Default Settings", new GUILayoutOption[0]))
            {
                ResetDefaults();
            }
            if (FsmEditorGUILayout.HelpButton("Online Help"))
            {
                EditorCommands.OpenWikiPage(WikiPages.Preferences);
            }
            GUILayout.EndHorizontal();
            EditorGUILayout.Space();
        }

        private static void ResetDefaults()
        {
            GraphViewLinkStyle = HutongGames.PlayMakerEditor.GraphViewLinkStyle.BezierLinks;
            NewStateName = "State";
            MaxReEnterStateCount = 100;
            AutoSelectGameObject = true;
            SelectStateOnActivated = true;
            JumpToBreakpoint = true;
            MirrorDebugLog = false;
            ShowEditWhileRunningWarning = true;
            SelectFSMInGameView = true;
            ShowCommentsInGraphView = true;
            DrawPlaymakerGizmos = true;
            DrawPlaymakerGizmoInHierarchy = true;
            AutoAddPlayMakerGUI = true;
            DimUnusedActionParameters = false;
            DebugLookAtColor = Color.grey;
            DebugRaycastColor = Color.grey;
            ShowHints = true;
            CloseActionBrowserOnEnter = false;
            SelectNewVariables = true;
            AddPrefabLabel = true;
            LoadAllPrefabs = true;
            AutoLoadPrefabs = true;
            UnloadPrefabs = true;
            StateMaxWidth = 200;
            ShowScrollBars = true;
            EnableWatermarks = true;
            ColorLinks = false;
            SnapGridSize = 0x10;
            EnableLogging = true;
            HideUnusedEvents = false;
            EdgeScrollSpeed = 5f;
            EdgeScrollZone = 100f;
            EnableRealtimeErrorChecker = true;
            DisableErrorCheckerWhenPlaying = true;
            CheckForRequiredComponent = true;
            CheckForRequiredField = true;
            CheckForEventNotUsed = true;
            CheckForTransitionMissingEvent = true;
            CheckForTransitionMissingTarget = true;
            CheckForDuplicateTransitionEvent = true;
            CheckForMouseEventErrors = true;
            CheckForCollisionEventErrors = true;
            CheckForPrefabRestrictions = true;
            CheckForObsoleteActions = true;
            DisableEditorWhenPlaying = false;
            DisableInspectorWhenPlaying = false;
            DisableToolWindowsWhenPlaying = true;
            DisableActionBrowerWhenPlaying = false;
            DisableEventBrowserWhenPlaying = false;
            ScreenshotsPath = "PlayMaker/Screenshots/";
            EnableDebugFlow = true;
            ApplySettings();
            SaveSettings();
        }

        public static void SaveSettings()
        {
            ValidateSettings();
            EditorPrefs.SetString("PlayMaker.ScreenshotsPath", ScreenshotsPath);
            EditorPrefs.SetString("PlayMaker.StartStateName", StartStateName);
            EditorPrefs.SetString("PlayMaker.NewStateName", NewStateName);
            EditorPrefs.SetBool("PlayMaker.AutoSelectGameObject", AutoSelectGameObject);
            EditorPrefs.SetBool("PlayMaker.SelectStateOnActivated", SelectStateOnActivated);
            EditorPrefs.SetBool("PlayMaker.GotoBreakpoint", JumpToBreakpoint);
            EditorPrefs.SetInt("PlayMaker.GameStateIconSize", GameStateIconSize);
            EditorPrefs.SetBool("PlayMaker.FrameSelectedState", FrameSelectedState);
            EditorPrefs.SetBool("PlayMaker.SyncLogSelection", SyncLogSelection);
            EditorPrefs.SetBool("PlayMaker.BreakpointsEnabled", BreakpointsEnabled);
            EditorPrefs.SetBool("PlayMaker.MirrorDebugLog", MirrorDebugLog);
            EditorPrefs.SetBool("PlayMaker.LockGraphView", LockGraphView);
            EditorPrefs.SetInt("PlayMaker.GraphLinkStyle", (int) GraphViewLinkStyle);
            EditorPrefs.SetBool("PlayMaker.KeepActionBrowserOpen", KeepActionBrowserOpen);
            EditorPrefs.SetBool("PlayMaker.ShowCommentsInGraphView", ShowCommentsInGraphView);
            EditorPrefs.SetBool("PlayMaker.ShowStateLabelsInGameView", ShowStateLabelsInGameView);
            EditorPrefs.SetBool("PlayMaker.ShowStateDescription", ShowStateDescription);
            EditorPrefs.SetBool("PlayMaker.ShowActionParameters", ShowActionParameters);
            EditorPrefs.SetBool("PlayMaker.DebugActionParameters", DebugActionParameters);
            EditorPrefs.SetBool("PlayMaker.DrawPlaymakerGizmos", DrawPlaymakerGizmos);
            EditorPrefs.SetBool("PlayMaker.DrawPlaymakerGizmoInHierarchy", DrawPlaymakerGizmoInHierarchy);
            EditorPrefs.SetBool("PlayMaker.ShowEditWhileRunningWarning", ShowEditWhileRunningWarning);
            EditorPrefs.SetInt("PlayMaker.MaxReenterStateCount", MaxReEnterStateCount);
            EditorPrefs.SetBool("PlayMaker.HideUnusedEvents", HideUnusedEvents);
            EditorPrefs.SetBool("PlayMaker.ShowActionPreview", ShowActionPreview);
            EditorPrefs.SetInt("PlayMaker.SelectedActionCategory", SelectedActionCategory);
            EditorPrefs.SetBool("PlayMaker.SelectFSMInGameView", SelectFSMInGameView);
            EditorPrefs.SetInt("PlayMaker.DebugLookAtColor", FsmEditorUtility.PackColorIntoInt(DebugLookAtColor));
            EditorPrefs.SetInt("PlayMaker.DebugRaycastColor", FsmEditorUtility.PackColorIntoInt(DebugRaycastColor));
            EditorPrefs.SetBool("PlayMaker.HideUnusedParams", HideUnusedParams);
            EditorPrefs.SetBool("PlayMaker.EnableRealtimeErrorChecker", EnableRealtimeErrorChecker);
            EditorPrefs.SetBool("PlayMaker.AutoAddPlayMakerGUI", AutoAddPlayMakerGUI);
            EditorPrefs.SetBool("PlayMaker.DimUnusedParameters", DimUnusedActionParameters);
            EditorPrefs.SetBool("PlayMaker.AddPrefabLabel", AddPrefabLabel);
            EditorPrefs.SetBool("PlayMaker.AutoLoadPrefabs", AutoLoadPrefabs);
            EditorPrefs.SetBool("PlayMaker.LoadAllPrefabs", LoadAllPrefabs);
            EditorPrefs.SetBool("PlayMaker.UnloadPrefabs", UnloadPrefabs);
            EditorPrefs.SetInt("PlayMaker.StateMaxWidth", StateMaxWidth);
            EditorPrefs.SetBool("PlayMaker.ShowScrollBars", ShowScrollBars);
            EditorPrefs.SetBool("PlayMaker.ShowWatermark", EnableWatermarks);
            EditorPrefs.SetInt("PlayMaker.SnapGridSize", SnapGridSize);
            EditorPrefs.SetBool("PlayMaker.EnableLogging", EnableLogging);
            EditorPrefs.SetBool("PlayMaker.DisableErrorCheckerWhenPlaying", DisableErrorCheckerWhenPlaying);
            EditorPrefs.SetBool("PlayMaker.ColorLinks", ColorLinks);
            EditorPrefs.SetBool("PlayMaker.HideObsoleteActions", HideObsoleteActions);
            EditorPrefs.SetFloat("PlayMaker.AutoPanSpeed", EdgeScrollSpeed);
            EditorPrefs.SetFloat("PlayMaker.AutoPanZone", EdgeScrollZone);
            EditorPrefs.SetBool("PlayMaker.ExpandDebuggingSettings", ExpandDebuggingSettings);
            EditorPrefs.SetBool("PlayMaker.ExpandErrorCheckSettings", ExpandErrorCheckSettings);
            EditorPrefs.SetBool("PlayMaker.ExpandFsmSettings", ExpandGeneralSettings);
            EditorPrefs.SetBool("PlayMaker.ExpandGraphViewSettings", ExpandGraphViewSettings);
            EditorPrefs.SetBool("PlayMaker.CheckForRequiredComponent", CheckForRequiredComponent);
            EditorPrefs.SetBool("PlayMaker.CheckForRequiredField", CheckForRequiredField);
            EditorPrefs.SetBool("PlayMaker.CheckForTransitionMissingEvent", CheckForTransitionMissingEvent);
            EditorPrefs.SetBool("PlayMaker.CheckForTransitionMissingTarget", CheckForTransitionMissingTarget);
            EditorPrefs.SetBool("PlayMaker.CheckForDuplicateTransitionEvent", CheckForDuplicateTransitionEvent);
            EditorPrefs.SetBool("PlayMaker.CheckForMouseEventErrors", CheckForMouseEventErrors);
            EditorPrefs.SetBool("PlayMaker.CheckForCollisionEventErrors", CheckForCollisionEventErrors);
            EditorPrefs.SetBool("PlayMaker.CheckForEventNotUsed", CheckForEventNotUsed);
            EditorPrefs.SetBool("PlayMaker.CheckForPrefabRestrictions", CheckForPrefabRestrictions);
            EditorPrefs.SetBool("PlayMaker.CheckForObsoleteActions", CheckForObsoleteActions);
            EditorPrefs.SetInt("PlayMaker.ColorScheme", (int) ColorScheme);
            EditorPrefs.SetBool("PlayMaker.DisableEditorWhenPlaying", DisableEditorWhenPlaying);
            EditorPrefs.SetBool("PlayMaker.DisableInspectorWhenPlaying", DisableInspectorWhenPlaying);
            EditorPrefs.SetBool("PlayMaker.DisableToolWindowsWhenPlaying", DisableToolWindowsWhenPlaying);
            EditorPrefs.SetBool("PlayMaker.DisableActionBrowerWhenPlaying", DisableActionBrowerWhenPlaying);
            EditorPrefs.SetBool("PlayMaker.DisableEventBrowserWhenPlaying", DisableEventBrowserWhenPlaying);
            EditorPrefs.SetBool("PlayMaker.ShowHints", ShowHints);
            EditorPrefs.SetBool("PlayMaker.CloseActionBrowserOnEnter", CloseActionBrowserOnEnter);
            EditorPrefs.SetBool("PlayMaker.LogPauseOnSelect", LogPauseOnSelect);
            EditorPrefs.SetBool("PlayMaker.LogHideUnusedEvents", LogHideUnusedEvents);
            EditorPrefs.SetBool("PlayMaker.LogShowSentBy", LogShowSentBy);
            EditorPrefs.SetBool("PlayMaker.LogCollapseSystemEvents", LogCollapseSystemEvents);
            EditorPrefs.SetBool("PlayMaker.EnableDebugFlow", EnableDebugFlow);
            EditorPrefs.SetInt("PlayMaker.ConsoleActionReportSortOptionIndex", ConsoleActionReportSortOptionIndex);
            EditorPrefs.SetBool("PlayMaker.DebugVariables", DebugVariables);
            EditorPrefs.SetBool("PlayMaker.SelectNewVariables", SelectNewVariables);
            EditorPrefs.SetBool("PlayMaker.FsmBrowserShowFullPath", FsmBrowserShowFullPath);
            FsmEditor.Repaint(true);
        }

        private static void ValidateSettings()
        {
            EdgeScrollSpeed = Mathf.Clamp(EdgeScrollSpeed, 1f, 20f);
            MaxReEnterStateCount = Mathf.Max(100, MaxReEnterStateCount);
        }

        public static bool AddPrefabLabel
        {
            [CompilerGenerated]
            get
            {
                return AddPrefabLabel__BackingField;
            }
            [CompilerGenerated]
            set
            {
                AddPrefabLabel__BackingField = value;
            }
        }

        public static bool AutoAddPlayMakerGUI
        {
            [CompilerGenerated]
            get
            {
                return AutoAddPlayMakerGUI__BackingField;
            }
            [CompilerGenerated]
            set
            {
                AutoAddPlayMakerGUI__BackingField = value;
            }
        }

        public static bool AutoLoadPrefabs
        {
            [CompilerGenerated]
            get
            {
                return AutoLoadPrefabs__BackingField;
            }
            [CompilerGenerated]
            set
            {
                AutoLoadPrefabs__BackingField = value;
            }
        }

        public static bool AutoSelectGameObject
        {
            [CompilerGenerated]
            get
            {
                return AutoSelectGameObject__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                AutoSelectGameObject__BackingField = value;
            }
        }

        public static bool BreakpointsEnabled
        {
            [CompilerGenerated]
            get
            {
                return BreakpointsEnabled__BackingField;
            }
            [CompilerGenerated]
            set
            {
                BreakpointsEnabled__BackingField = value;
            }
        }

        public static bool CheckForCollisionEventErrors
        {
            [CompilerGenerated]
            get
            {
                return CheckForCollisionEventErrors__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForCollisionEventErrors__BackingField = value;
            }
        }

        public static bool CheckForDuplicateTransitionEvent
        {
            [CompilerGenerated]
            get
            {
                return CheckForDuplicateTransitionEvent__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForDuplicateTransitionEvent__BackingField = value;
            }
        }

        public static bool CheckForEventNotUsed
        {
            [CompilerGenerated]
            get
            {
                return CheckForEventNotUsed__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForEventNotUsed__BackingField = value;
            }
        }

        public static bool CheckForMouseEventErrors
        {
            [CompilerGenerated]
            get
            {
                return CheckForMouseEventErrors__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForMouseEventErrors__BackingField = value;
            }
        }

        public static bool CheckForObsoleteActions
        {
            [CompilerGenerated]
            get
            {
                return CheckForObsoleteActions__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForObsoleteActions__BackingField = value;
            }
        }

        public static bool CheckForPrefabRestrictions
        {
            [CompilerGenerated]
            get
            {
                return CheckForPrefabRestrictions__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForPrefabRestrictions__BackingField = value;
            }
        }

        public static bool CheckForRequiredComponent
        {
            [CompilerGenerated]
            get
            {
                return CheckForRequiredComponent__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForRequiredComponent__BackingField = value;
            }
        }

        public static bool CheckForRequiredField
        {
            [CompilerGenerated]
            get
            {
                return CheckForRequiredField__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForRequiredField__BackingField = value;
            }
        }

        public static bool CheckForTransitionMissingEvent
        {
            [CompilerGenerated]
            get
            {
                return CheckForTransitionMissingEvent__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForTransitionMissingEvent__BackingField = value;
            }
        }

        public static bool CheckForTransitionMissingTarget
        {
            [CompilerGenerated]
            get
            {
                return CheckForTransitionMissingTarget__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CheckForTransitionMissingTarget__BackingField = value;
            }
        }

        public static bool CloseActionBrowserOnEnter
        {
            [CompilerGenerated]
            get
            {
                return CloseActionBrowserOnEnter__BackingField;
            }
            [CompilerGenerated]
            set
            {
                CloseActionBrowserOnEnter__BackingField = value;
            }
        }

        public static bool ColorLinks
        {
            [CompilerGenerated]
            get
            {
                return ColorLinks__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ColorLinks__BackingField = value;
            }
        }

        public static HutongGames.PlayMakerEditor.FsmEditorStyles.ColorScheme ColorScheme
        {
            [CompilerGenerated]
            get
            {
                return ColorScheme__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ColorScheme__BackingField = value;
            }
        }

        public static int ConsoleActionReportSortOptionIndex
        {
            [CompilerGenerated]
            get
            {
                return ConsoleActionReportSortOptionIndex__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ConsoleActionReportSortOptionIndex__BackingField = value;
            }
        }

        public static bool DebugActionParameters
        {
            [CompilerGenerated]
            get
            {
                return DebugActionParameters__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DebugActionParameters__BackingField = value;
            }
        }

        public static Color DebugLookAtColor
        {
            [CompilerGenerated]
            get
            {
                return DebugLookAtColor__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DebugLookAtColor__BackingField = value;
            }
        }

        public static Color DebugRaycastColor
        {
            [CompilerGenerated]
            get
            {
                return DebugRaycastColor__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DebugRaycastColor__BackingField = value;
            }
        }

        public static bool DebugVariables
        {
            [CompilerGenerated]
            get
            {
                return DebugVariables__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DebugVariables__BackingField = value;
            }
        }

        public static bool DimUnusedActionParameters
        {
            [CompilerGenerated]
            get
            {
                return DimUnusedActionParameters__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DimUnusedActionParameters__BackingField = value;
            }
        }

        public static bool DisableActionBrowerWhenPlaying
        {
            [CompilerGenerated]
            get
            {
                return DisableActionBrowerWhenPlaying__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DisableActionBrowerWhenPlaying__BackingField = value;
            }
        }

        public static bool DisableEditorWhenPlaying
        {
            [CompilerGenerated]
            get
            {
                return DisableEditorWhenPlaying__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DisableEditorWhenPlaying__BackingField = value;
            }
        }

        public static bool DisableErrorCheckerWhenPlaying
        {
            [CompilerGenerated]
            get
            {
                return DisableErrorCheckerWhenPlaying__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DisableErrorCheckerWhenPlaying__BackingField = value;
            }
        }

        public static bool DisableEventBrowserWhenPlaying
        {
            [CompilerGenerated]
            get
            {
                return DisableEventBrowserWhenPlaying__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DisableEventBrowserWhenPlaying__BackingField = value;
            }
        }

        public static bool DisableInspectorWhenPlaying
        {
            [CompilerGenerated]
            get
            {
                return DisableInspectorWhenPlaying__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DisableInspectorWhenPlaying__BackingField = value;
            }
        }

        public static bool DisableToolWindowsWhenPlaying
        {
            [CompilerGenerated]
            get
            {
                return DisableToolWindowsWhenPlaying__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DisableToolWindowsWhenPlaying__BackingField = value;
            }
        }

        public static bool DrawPlaymakerGizmoInHierarchy
        {
            [CompilerGenerated]
            get
            {
                return DrawPlaymakerGizmoInHierarchy__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DrawPlaymakerGizmoInHierarchy__BackingField = value;
            }
        }

        public static bool DrawPlaymakerGizmos
        {
            [CompilerGenerated]
            get
            {
                return DrawPlaymakerGizmos__BackingField;
            }
            [CompilerGenerated]
            set
            {
                DrawPlaymakerGizmos__BackingField = value;
            }
        }

        public static float EdgeScrollSpeed
        {
            [CompilerGenerated]
            get
            {
                return EdgeScrollSpeed__BackingField;
            }
            [CompilerGenerated]
            set
            {
                EdgeScrollSpeed__BackingField = value;
            }
        }

        public static float EdgeScrollZone
        {
            [CompilerGenerated]
            get
            {
                return EdgeScrollZone__BackingField;
            }
            [CompilerGenerated]
            set
            {
                EdgeScrollZone__BackingField = value;
            }
        }

        public static bool EnableDebugFlow
        {
            [CompilerGenerated]
            get
            {
                return EnableDebugFlow__BackingField;
            }
            [CompilerGenerated]
            set
            {
                EnableDebugFlow__BackingField = value;
            }
        }

        public static bool EnableLogging
        {
            [CompilerGenerated]
            get
            {
                return EnableLogging__BackingField;
            }
            [CompilerGenerated]
            set
            {
                EnableLogging__BackingField = value;
            }
        }

        public static bool EnableRealtimeErrorChecker
        {
            [CompilerGenerated]
            get
            {
                return EnableRealtimeErrorChecker__BackingField;
            }
            [CompilerGenerated]
            set
            {
                EnableRealtimeErrorChecker__BackingField = value;
            }
        }

        public static bool EnableWatermarks
        {
            [CompilerGenerated]
            get
            {
                return EnableWatermarks__BackingField;
            }
            [CompilerGenerated]
            set
            {
                EnableWatermarks__BackingField = value;
            }
        }

        private static bool ExpandDebuggingSettings
        {
            [CompilerGenerated]
            get
            {
                return ExpandDebuggingSettings__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ExpandDebuggingSettings__BackingField = value;
            }
        }

        private static bool ExpandErrorCheckSettings
        {
            [CompilerGenerated]
            get
            {
                return ExpandErrorCheckSettings__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ExpandErrorCheckSettings__BackingField = value;
            }
        }

        private static bool ExpandGeneralSettings
        {
            [CompilerGenerated]
            get
            {
                return ExpandGeneralSettings__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ExpandGeneralSettings__BackingField = value;
            }
        }

        private static bool ExpandGraphViewSettings
        {
            [CompilerGenerated]
            get
            {
                return ExpandGraphViewSettings__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ExpandGraphViewSettings__BackingField = value;
            }
        }

        public static bool FrameSelectedState
        {
            [CompilerGenerated]
            get
            {
                return FrameSelectedState__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                FrameSelectedState__BackingField = value;
            }
        }

        public static bool FsmBrowserShowFullPath
        {
            [CompilerGenerated]
            get
            {
                return FsmBrowserShowFullPath__BackingField;
            }
            [CompilerGenerated]
            set
            {
                FsmBrowserShowFullPath__BackingField = value;
            }
        }

        public static int GameStateIconSize
        {
            [CompilerGenerated]
            get
            {
                return GameStateIconSize__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                GameStateIconSize__BackingField = value;
            }
        }

        public static HutongGames.PlayMakerEditor.GraphViewLinkStyle GraphViewLinkStyle
        {
            [CompilerGenerated]
            get
            {
                return GraphViewLinkStyle__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                GraphViewLinkStyle__BackingField = value;
            }
        }

        public static bool HideObsoleteActions
        {
            [CompilerGenerated]
            get
            {
                return HideObsoleteActions__BackingField;
            }
            [CompilerGenerated]
            set
            {
                HideObsoleteActions__BackingField = value;
            }
        }

        public static bool HideUnusedEvents
        {
            [CompilerGenerated]
            get
            {
                return HideUnusedEvents__BackingField;
            }
            [CompilerGenerated]
            set
            {
                HideUnusedEvents__BackingField = value;
            }
        }

        public static bool HideUnusedParams
        {
            [CompilerGenerated]
            get
            {
                return HideUnusedParams__BackingField;
            }
            [CompilerGenerated]
            set
            {
                HideUnusedParams__BackingField = value;
            }
        }

        public static bool JumpToBreakpoint
        {
            [CompilerGenerated]
            get
            {
                return JumpToBreakpoint__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                JumpToBreakpoint__BackingField = value;
            }
        }

        public static bool KeepActionBrowserOpen
        {
            [CompilerGenerated]
            get
            {
                return KeepActionBrowserOpen__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                KeepActionBrowserOpen__BackingField = value;
            }
        }

        public static bool LoadAllPrefabs
        {
            [CompilerGenerated]
            get
            {
                return LoadAllPrefabs__BackingField;
            }
            [CompilerGenerated]
            set
            {
                LoadAllPrefabs__BackingField = value;
            }
        }

        public static bool LockGraphView
        {
            [CompilerGenerated]
            get
            {
                return LockGraphView__BackingField;
            }
            [CompilerGenerated]
            set
            {
                LockGraphView__BackingField = value;
            }
        }

        public static bool LogCollapseSystemEvents
        {
            [CompilerGenerated]
            get
            {
                return LogCollapseSystemEvents__BackingField;
            }
            [CompilerGenerated]
            set
            {
                LogCollapseSystemEvents__BackingField = value;
            }
        }

        public static bool LogHideUnusedEvents
        {
            [CompilerGenerated]
            get
            {
                return LogHideUnusedEvents__BackingField;
            }
            [CompilerGenerated]
            set
            {
                LogHideUnusedEvents__BackingField = value;
            }
        }

        public static bool LogPauseOnSelect
        {
            [CompilerGenerated]
            get
            {
                return LogPauseOnSelect__BackingField;
            }
            [CompilerGenerated]
            set
            {
                LogPauseOnSelect__BackingField = value;
            }
        }

        public static bool LogShowSentBy
        {
            [CompilerGenerated]
            get
            {
                return LogShowSentBy__BackingField;
            }
            [CompilerGenerated]
            set
            {
                LogShowSentBy__BackingField = value;
            }
        }

        public static int MaxReEnterStateCount
        {
            [CompilerGenerated]
            get
            {
                return MaxReEnterStateCount__BackingField;
            }
            [CompilerGenerated]
            set
            {
                MaxReEnterStateCount__BackingField = value;
            }
        }

        public static bool MirrorDebugLog
        {
            [CompilerGenerated]
            get
            {
                return MirrorDebugLog__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                MirrorDebugLog__BackingField = value;
            }
        }

        public static string NewStateName
        {
            [CompilerGenerated]
            get
            {
                return NewStateName__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                NewStateName__BackingField = value;
            }
        }

        public static string ScreenshotsPath
        {
            [CompilerGenerated]
            get
            {
                return ScreenshotsPath__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ScreenshotsPath__BackingField = value;
            }
        }

        public static int SelectedActionCategory
        {
            [CompilerGenerated]
            get
            {
                return SelectedActionCategory__BackingField;
            }
            [CompilerGenerated]
            set
            {
                SelectedActionCategory__BackingField = value;
            }
        }

        public static bool SelectFSMInGameView
        {
            [CompilerGenerated]
            get
            {
                return SelectFSMInGameView__BackingField;
            }
            [CompilerGenerated]
            set
            {
                SelectFSMInGameView__BackingField = value;
            }
        }

        public static bool SelectNewVariables
        {
            [CompilerGenerated]
            get
            {
                return SelectNewVariables__BackingField;
            }
            [CompilerGenerated]
            set
            {
                SelectNewVariables__BackingField = value;
            }
        }

        public static bool SelectStateOnActivated
        {
            [CompilerGenerated]
            get
            {
                return SelectStateOnActivated__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                SelectStateOnActivated__BackingField = value;
            }
        }

        public static bool ShowActionParameters
        {
            [CompilerGenerated]
            get
            {
                return ShowActionParameters__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ShowActionParameters__BackingField = value;
            }
        }

        public static bool ShowActionPreview
        {
            [CompilerGenerated]
            get
            {
                return ShowActionPreview__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ShowActionPreview__BackingField = value;
            }
        }

        public static bool ShowCommentsInGraphView
        {
            [CompilerGenerated]
            get
            {
                return ShowCommentsInGraphView__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                ShowCommentsInGraphView__BackingField = value;
            }
        }

        public static bool ShowEditWhileRunningWarning
        {
            [CompilerGenerated]
            get
            {
                return ShowEditWhileRunningWarning__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                ShowEditWhileRunningWarning__BackingField = value;
            }
        }

        public static bool ShowHints
        {
            [CompilerGenerated]
            get
            {
                return ShowHints__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ShowHints__BackingField = value;
            }
        }

        public static bool ShowScrollBars
        {
            [CompilerGenerated]
            get
            {
                return ShowScrollBars__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ShowScrollBars__BackingField = value;
            }
        }

        public static bool ShowStateDescription
        {
            [CompilerGenerated]
            get
            {
                return ShowStateDescription__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ShowStateDescription__BackingField = value;
            }
        }

        public static bool ShowStateLabelsInGameView
        {
            [CompilerGenerated]
            get
            {
                return ShowStateLabelsInGameView__BackingField;
            }
            [CompilerGenerated]
            set
            {
                ShowStateLabelsInGameView__BackingField = value;
            }
        }

        public static int SnapGridSize
        {
            [CompilerGenerated]
            get
            {
                return SnapGridSize__BackingField;
            }
            [CompilerGenerated]
            set
            {
                SnapGridSize__BackingField = value;
            }
        }

        public static string StartStateName
        {
            [CompilerGenerated]
            get
            {
                return StartStateName__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                StartStateName__BackingField = value;
            }
        }

        public static int StateMaxWidth
        {
            [CompilerGenerated]
            get
            {
                return StateMaxWidth__BackingField;
            }
            [CompilerGenerated]
            set
            {
                StateMaxWidth__BackingField = value;
            }
        }

        public static bool SyncLogSelection
        {
            [CompilerGenerated]
            get
            {
                return SyncLogSelection__BackingField;
            }
            [CompilerGenerated]
            private set
            {
                SyncLogSelection__BackingField = value;
            }
        }

        public static bool UnloadPrefabs
        {
            [CompilerGenerated]
            get
            {
                return UnloadPrefabs__BackingField;
            }
            [CompilerGenerated]
            set
            {
                UnloadPrefabs__BackingField = value;
            }
        }
    }
}

